const utils = require('./utils')

function initGcodeParams(gcodeParams) {
    gcodeParams = Object.assign({
        // xOffset: 0,  // x 方向偏移量，单位 mm
        // yOffset: 0, // y 方向偏移量，单位 mm
        isRelativeCoord: false, // Gcode 是否使用相对坐标
        width: 10,  // 图片实际宽度，单位 mm
        height: 10, // 图片实际高度，单位 mm
        laserOnCode: 'M4', // 打开激光的 GCode 代码
        laserOffCode: 'M5', // 关闭激光的 GCode 代码、程序结束指令
        feedRate: 100, // 进给速度 /G1 速度，当前代码不处理这个速度设置
        rapidRate: 1000, // G0 速度 / 振镜速度 单位 mm/min
        pixelThreshold: 127, // 像素阈值，用于黑白打点模式
        bitmapMode: 0, // 打标计算模式：0-灰度扫描 1- 黑白扫描 2- 灰度打点 3-黑白打点
        rateUnit: 'mm/min', // 速度单位
        laserPowerMaxS: 255, // 最大激光功率的 S 值
        laserPowerMinS: 0, // 最小激光功率的 S 值
        gray255Power: true, 
        minGray: 0,
        maxGray: 255,
        xScaling: 1.0, // 缩放因子，用于放大或缩小图片
        yScaling: 1.0,
        matrix: [1, 0, 0, 1, 50, 50],
        canvasMatrix: [1, 0, 0, -1, -50, 50], // 画布坐标系矩阵,  平移（-50， -50）， 沿x轴镜像， 再逆时针旋转 90 度
        positionPrecision: 3, // gcode 坐标精度，保存到小数点的位数
        markMode: 0, // 打标模式： 0：平面达标 1：扩副打标 2：旋转打标（抓盘）3：滚轴 
        previewMode: -1, // -1：非预览 1：轮廓预览 2：元素预览 3：旋转模式直线预览 4：旋转模式路径预览
        times: 1, // 打标次数 TODO: 待实现
        dither: 'JarvisJudiceNinke', // 默认使用 stucki 抖动算法
        // dither: 3, // 默认使用 stucki 抖动算法
        dotTime: 200, // 点雕刻时间，单位 us，默认 200us
        useGrid: false, // 启用网格，默认 false
        simulation: false, // 是否仿真，默认 false
        gamma: 0.4545, // 伽马校正参数，默认 1
        serpentine: false, // 启用双向扫描，默认 false
        interpTimes: 0, // 插值次数，默认 3
        scanDir: 'X', // 扫描方向，默认 X 轴，可选 'X' 或 'Y'
        isHandhoudMode: false, // 是否手持模式，默认 false
        frequency: 30, // 振镜频率，默认 30kHz
        swapXY: false, // 是否交换 X 和 Y 轴，默认 false
        onLightDelay: 90, // 默认开光延迟
        offLightDelay: 190, // 默认关光延迟
        jumpDelay: 300, // 默认跳转延迟
        cornerDelay: 80, // 默认拐角延迟
        rotateParams: {
            // mode: 'clamp', // clamp: 夹爪  roller：抓盘
            diameter: 64.331, // 打标物体直径，单位 mm
            perRevolutionPulsesClamp: 12800, // 抓盘每转脉冲数
            perRevolutionPulsesRoller: 12800, // 滚轴每转脉冲数
            rollerDiameter: 20, // 滚轴直径
            mirrorImage: true, // 镜像输出
            gcodeMaxAngle: 540, // gcode 限制的最大角度
            transmissionRatio: 4
        },
        reliefMode: {
            enabled: false, // 是否启用浮雕模式
            depth: 32, // 浮雕深度，即分层数，默认 256
            scanAngleIncrement: 45, // 浮雕扫描角度增量，默认 90°
            curPlies: 1, // 当前层数 
            isIntaglioCarving: true // 默认阴雕模式
        }
    }, gcodeParams);

    let gcp = gcodeParams;

    gcp.laserXBeamSize = gcp.DPI ? 25.4 / gcp.DPI : 0.05;
    gcp.laserYBeamSize = gcp.laserXBeamSize;
    gcp.laserZBeamSize = gcp.laserXBeamSize;
    gcp.laserABeamSize = gcp.laserXBeamSize;
    gcp.laserABeamSizeActual = gcp.laserABeamSize;
    gcp.initBeamSize = utils.roundFun(gcp.laserXBeamSize, 3);

    // TODO: 这部分判断应该和 process 里的if else 合并
    if (gcp.markMode === 0) {// 平面模式
        gcp.useX = true;
        gcp.useY = true;
        gcp.useZ = false;
        gcp.useA = false;
    } else if (gcp.markMode === 2 || gcp.markMode === 3) { // 圆柱模式
        gcp.useX = false;
        gcp.useY = true;
        gcp.useZ = false;
        gcp.useA = true;

    } else if (gcp.markMode === 1) { // 扩幅模式
        gcp.useX = true;
        gcp.useY = true;
        gcp.useZ = true;
        gcp.useA = false;
    }
 
    if (gcp.isHandhoudMode) {
        gcp.canvasMatrix = gcp.canvasMatrix.map(function(x) { return -x; });;
        // m = concatArray([-1, 0, 0, -1, 0, 0], m); // 仿真坐标系变换到实际坐标系
    }

    if (gcp.markMode === 2 || 
        gcp.markMode === 3 || 
        gcp.scanDir === 'Y') { // 圆柱模式
        gcp.swapXY = true; // 交换 X 和 Y 轴
    }

    // 扫描模式且插值
    // TODO： 加入 scanDir 为 Y 时的逻辑，支持扩幅模式
    if (gcp.interpTimes !== 0 && (gcp.bitmapMode === 0 || gcp.bitmapMode === 1)) {
        gcp.interpTimes += 1; // 插一条线高度就是 2 倍, 插两条就是 3 倍
        if (gcp.scanDir === 'X') {
            if (gcp.markMode === 0) gcp.laserYBeamSize = gcp.laserYBeamSize / gcp.interpTimes;
            else if (gcp.markMode === 2) gcp.laserABeamSize = gcp.laserABeamSize / gcp.interpTimes;
        }
        else gcp.laserXBeamSize = gcp.laserXBeamSize / gcp.interpTimes;
    }


     // 抓盘打标
    if (gcp.markMode === 2) { 
        let l = gcp.laserABeamSize; // 一个像素点的弧长
        let d = gcp.rotateParams.diameter; // 打标物体直径
        let p = 360 / gcp.rotateParams.perRevolutionPulsesClamp; // 脉冲数12800，一个脉冲 0.028125 度
        // gcp.laserABeamSize = l * 360 / (Math.PI * d); // 圆柱打标，弧长为 360°
        let numPixelPulse = Math.round(l * 360 / (Math.PI * d) /  p) ; // 圆柱打标，弧长为 360°
        gcp.laserABeamSize = utils.roundFun(numPixelPulse * p, 3) ; // 将精度固定到后三位
        gcp.laserABeamSizeActual = numPixelPulse * p;
        // 修正 BeamSize 的值，使得图片不变形 
        gcp.laserXBeamSize = numPixelPulse * p * Math.PI * d / 360 ; 
        gcp.laserYBeamSize = gcp.laserXBeamSize; 
        gcp.laserXBeamSizeActual =  gcp.laserXBeamSize;
        gcp.laserXBeamSize = utils.roundFun(gcp.laserXBeamSize, 3);

        if(gcp.isRelativeCoord) gcp.xScaling = gcp.laserXBeamSize / gcp.laserXBeamSizeActual;
        // if(gcp.isRelativeCoord) scaling = gcp.laserABeamSize / gcp.laserABeamSizeActual;
        // // 修正 图片大小
        // gcp.width = gcp.width * gcp.laserABeamSize / gcp.laserABeamSizeActual;
        // gcp.height = gcp.height * gcp.laserABeamSize / gcp.laserABeamSizeActual;
    }else if(gcp.markMode === 3) {
        if (!gcp.rotateParams.transmissionRatio){
            if (gcp.rotateParams.perRevolutionPulsesClamp && gcp.rotateParams.perRevolutionPulsesRoller){
                gcp.rotateParams.transmissionRatio = gcp.rotateParams.perRevolutionPulsesClamp / gcp.rotateParams.perRevolutionPulsesRoller;
            }else{
                gcp.rotateParams.transmissionRatio = 4; 
            }
        }  
        let l = gcp.laserABeamSize; // 一个像素点的弧长
        let d = gcp.rotateParams.diameter; // 打标物体直径
        let rd = gcp.rotateParams.rollerDiameter * gcp.rotateParams.transmissionRatio; // 滚轴直径

        let p = 360 / gcp.rotateParams.perRevolutionPulsesClamp; // 脉冲数12800，一个脉冲 0.028125 度

        let unitArcLength = Math.PI * rd / gcp.rotateParams.perRevolutionPulsesClamp; // 一个脉冲对应的弧长
        let numPixelPulse = Math.round( l / unitArcLength);
        if (numPixelPulse == 0 ) numPixelPulse = 1;

        gcp.laserABeamSize = utils.roundFun(numPixelPulse * p, 3); // 将精度固定到后三位
        gcp.laserABeamSizeActual = numPixelPulse * p;
        // 修正 BeamSize 的值，使得图片不变形 
        gcp.laserXBeamSize = unitArcLength * numPixelPulse; 
        gcp.laserYBeamSize = gcp.laserXBeamSize; 
        gcp.laserXBeamSizeActual =  gcp.laserXBeamSize;
        gcp.laserXBeamSize =utils.roundFun(gcp.laserXBeamSize, 3);
        if(!gcp.rotateParams.gcodeMaxAngle) gcp.rotateParams.gcodeMaxAngle = 540; // 最大角度有可能
        if(gcp.isRelativeCoord) gcp.xScaling = gcp.laserXBeamSize / gcp.laserXBeamSizeActual;
        
    }
    
    // 处理浮雕模式
    if (gcp.reliefMode.enabled) {
        let depth = gcp.reliefMode.depth;
    }

    // 将精度固定，避免累计误差
    gcp.laserXBeamSize = Math.round( gcp.laserXBeamSize * 1000) / 1000;
    gcp.laserYBeamSize = Math.round( gcp.laserYBeamSize * 1000) / 1000;
    gcp.laserZBeamSize = Math.round( gcp.laserZBeamSize * 1000) / 1000;
    gcp.laserABeamSize = Math.ceil( gcp.laserABeamSize * 1000) / 1000; // A 轴

    gcp.xOffset = 0;  // x 方向偏移量，单位 mm
    gcp.yOffset = 0; // y 方向偏移量，单位 mm
    gcp.zOffset = 0; // z 方向偏移量，单位 mm
    gcp.aOffset = 0; // 圆柱偏移量，单位 mm
    return gcodeParams;
}

function initBitmapParams(bitmapData) {
    return Object.assign({
        gamma: -0.54545454, // 范围为（-1，+无穷）
        brightness: 0.04, // 范围（-0.1，+0.1） , 默认为对比度的一半
        contrast: 0.08 // 默认调高对比度，避免一些背景接近白色的被识别
    }, bitmapData);
}

module.exports = { initGcodeParams, initBitmapParams };